home *** CD-ROM | disk | FTP | other *** search
/ Floppyshop 2 / Floppyshop - 2.zip / Floppyshop - 2.iso / diskmags / 0022-3.564 / dmg-3313 / news.txt / c_part3.asc < prev    next >
Text File  |  1989-04-05  |  12KB  |  389 lines
  1.  
  2.  
  3.  
  4.                                  ALL AT C
  5.  
  6.                            Part 3 - Dave Mooney
  7.  
  8. In  part 2 of this tutorial I covered how to print characters and  numbers
  9. to the screen and briefly touched on getting input from the user. Unfortu-
  10. nately I did not go into this in as much detail as I would have liked  due 
  11. to lack of time.
  12.  
  13. This time I will cover control loops and arithmetic operations and go into 
  14. more detail on how to input data to your programs.
  15.  
  16.  
  17. CONTROL LOOPS:
  18. ==============
  19.  
  20. The control loops are:
  21.  
  22. FOR LOOP, these are roughly equivalent to the For...Next...Step loops used            
  23.           in BASIC. The main difference is that it is possible to have 
  24.           more than one starting, ending and step conditions.
  25.  
  26. WHILE LOOP, there  are  two  types  of while loop available in C. These  
  27.             translate to the pre-conditioned loop (While...End While) and
  28.             the post-conditioned loop (Repeat...Until) available in Basic.
  29.  
  30. While it is often possible to any of the loop constructs in the same piece 
  31. of program, one will be more suited than the others. 
  32.  
  33.  
  34. FOR loop syntax
  35. ---------------
  36.  
  37.           for(exp1;exp2;exp3)
  38.              {
  39.               statements
  40.               }
  41.  
  42.  
  43. exp1 is the starting values for the variables used in the loop. If more 
  44.       than one assignation is used they should be separated by commas.
  45.  
  46. exp2  while this condition is true the statements for the loop will be 
  47.       executed. More than one condition may be set, each separated by 
  48.       commas.
  49.  
  50. exp3  is the actions on the variables used in the loop. Again more that 
  51.       one may be used and each separated by commas.
  52.  
  53. statements  can be one or more program lines. If more than one line is 
  54.             used they should be enclosed by braces {}.
  55.  
  56. While  it is fairly easy to accept that more  than  one  variable  may  be
  57. initialised,  be used for the exit conditions or updated on each iteration 
  58. it is a bit harder to accept that none of the conditions need to be set at 
  59. all. When this happens the loop will be 'endless'. What can be appropriate 
  60. though is that the initial conditions or the increments are set within the 
  61. body of the loop.
  62.  
  63.  
  64. Simple          :   for(i=1;i<100;i++)
  65.                     {                        
  66.                        printf("%d\n",i);
  67.                      }
  68. This loop  will start with i=1 and execute the statements  in  the  braces
  69. while i<100. i is incremented (i++) by one each time.
  70.  
  71.  
  72. Multi assignment:   for(i=1,j=2;j<50;i++,j+=2)
  73.                     {
  74.                        printf("%d  %d\n",i,j);
  75.                      }
  76. Here the loop starts with i=1 and j=2.  The statements are executed  while
  77. j<50. i is incremented by 1 and j by 2.
  78.  
  79.  
  80. Some of each    :   for(i=10,j=20;j<100;)
  81.                     {
  82.                        printf("%d  %d\n",i,j);
  83.                        j=j+5;
  84.                      }  
  85. This time the loop starts with i=10 and j=20.  The end condition is j<100, 
  86. but there is no incremental part defined.  The  statements  execute  until
  87. j=100 and the end condition (exp2) becomes false.
  88.  
  89. i and j are printed on each iteration of the loop and j is incremented  by 
  90. 5.
  91.  
  92.  
  93. To try these out in a program you will need:
  94.  
  95.  
  96. # include "stdio.h"
  97.  
  98. main()
  99. {
  100.    int i,j;
  101.  
  102.    for(i=32;i=127;i++)     \* replace the various examples here *\
  103.    {  
  104.       printf("%d\n",i);
  105.     }
  106.    j=getchar();             \* holds output on screen for examination *\
  107.   }
  108.  
  109.  
  110. WHILE loop syntax
  111. -----------------
  112.  
  113.           while(exp1)
  114.           {  
  115.              statements
  116.            }
  117.  
  118.  
  119. exp1  is a condition that causes the loop to execute its associated 
  120.       statements (when it is true) or terminate (when it is false).
  121.  
  122. statements can be one or more program lines. They are bound by braces {}
  123.  
  124. This version of the while loop is used when the values in exp1 are already 
  125. known. It is called a pre-conditioned loop and is similar to the WHILE... 
  126. WHILE END loop in BASIC. 
  127.  
  128. If the condition of exp1 is true the statements will be executed until  it 
  129. becomes false.
  130.  
  131.  
  132. An example:
  133.  
  134. # include "stdio.h"
  135.  
  136. main()                     \* will print numbers 1 - 99 *\
  137. {
  138.    int i;
  139.  
  140.    i=1;
  141.  
  142.    while(i<100)
  143.    {
  144.       printf("%d\n",i);
  145.       i++;
  146.     }
  147.    i=getchar();
  148.  }
  149.  
  150.  
  151. DO...WHILE loop syntax
  152. ----------------------
  153.  
  154.           do
  155.           {
  156.              statements
  157.            }
  158.           while(exp1);
  159.  
  160. statements can be one or more program lines. They are bound by braces {}
  161.  
  162. exp1  is a condition that causes the loop to re-execute its associated 
  163.       statements (when it is true) or terminate (when it is false).
  164.  
  165.       Note the semi colon after 'while(exp1)'.
  166.  
  167. This  version of the while loop is used when the values  in  exp1  are un-
  168. known.  It  is called a  post-conditioned  loop  and  is  similar  to  the
  169. REPEAT...UNTIL loop in BASIC. 
  170.  
  171. The  statements in the loop will always execute at least once.  They  will
  172. continue to be executed until the condition of exp1 becomes false. 
  173.  
  174. An example:
  175.  
  176.  
  177. # include "stdio.h"
  178.  
  179. main()                     \* will print numbers 255 - 100 *\
  180. {
  181.    int i,j;
  182.  
  183.    j=255;
  184.  
  185.    do
  186.    {
  187.       i=j;      
  188.       printf("%d\n",i);
  189.       j=j-1;
  190.     }
  191.     while (i>100);
  192.     i=getchar();
  193.  }
  194.  
  195.  
  196. ARITHMETIC EXPRESSIONS
  197. ======================
  198.  
  199. Up until now any operations on variables in the example programs have been 
  200. fairly simple. This is not because arithmetic or logic is any different or 
  201. difficult in C,  but that it is  represented  slightly  differently.  What
  202. follows is a list,  broken down into groups. It is probably best  just  to
  203. read it and then use it as a reference when they crop up in programs. 
  204.  
  205.  
  206. C has 45 operators organised in 9 groups.  The operators in each have  the
  207. same precedence. The groups are listed in highest to lowest precedence and 
  208. associativity is given.
  209.  
  210.  
  211. Group     Operator                       Associativity       Example
  212. --------------------------------------------------------------------------
  213.   1       () function call               left to right       getchar(i)
  214.           [] array element reference                         i[17]
  215.           -> pointer to structure                            a->b
  216.           .  structure member reference                      a.b
  217.  
  218.  
  219.   2       -  unary minus                 left to right       -a
  220.           ++ increment                                       a++
  221.           -- decrement                                       a--
  222.           !  logical negation (NOT)                          ! found
  223.           ~  ones compliment                                 ~Ox7f
  224.           *  indirection                                     * pointr
  225.           &  address off                                     &a
  226.           sizeof size of variable or type                    sizeof(a)
  227.           ('type')  cast                                     (int) c
  228.  
  229.   
  230.   3       *  multiplication              left to right       a*b
  231.           /  division                                        a/b
  232.           %  modulus                                         a%b
  233.  
  234.  
  235.   4       +  addition                    left to right       a+b
  236.           -  subtraction                                     a-b
  237.  
  238.  
  239.   5       <<  bit shift left             left to right       a<<2
  240.           >>  bit shift right                                a>>3
  241.  
  242.  
  243.   6       <  less than                   left to right       a<b
  244.           >  greater than                                    a>b
  245.           <= less than or equal to                           a<=b
  246.           >= greater than or equal to                        a>=b
  247.  
  248.  
  249.   7       == equal to                    left to right       a==b
  250.           != not equal to                                    a!=b
  251.  
  252.  
  253.   8       &  bitwise and                 left to right       a&b
  254.  
  255.  
  256.   9       ^  bitwise exclusive or        left to right       a^b
  257.  
  258.  
  259.  10       |  bitwise or                  left to right       a|b
  260.  
  261.  
  262.  11       && logical and                 left to right       a==4&&b++3
  263.  
  264.  
  265.  12       || logical or                  left to right       a==3||b!=4
  266.  
  267.  
  268.  13       ?: conditional expression      right to left       a>?a:b
  269.  
  270.  
  271.  14       =  assignment                  right to left       a=5
  272.           *= multiply then assign                            a*=5
  273.           /= divide then assign                              a/=6
  274.           %= modulus divide then assign                      a%=5
  275.           += add then assign                                 a+=3
  276.           -= subtract then assign                            a-=4
  277.           &= bitwise and then assign                         a&=O333
  278.           ^= bitwise exclusive or then assign                a^=O123
  279.           |= bitwise or then assign                          a|=Ox77
  280.           <<= bitshift left then assign                      a<<=3
  281.           >>= bitshift right then assign                     a>>=2
  282.  
  283.  
  284.  15       ,  evaluate and then discard   right to left       a=4,b
  285.  
  286.  
  287.  
  288. MORE INPUT AND OUTPUT
  289. =====================
  290.  
  291. So far we have only touched on input and output. An example of output that 
  292. we have used from the beginning is 'printf()',  an  example  of  input  is
  293.  
  294. 'getchar()'.
  295.  
  296. The getchar() function reads from the standard input device, ie  the  key-
  297. board  and returns the result in a variable.  It  also  has  an  'opposite
  298. function,  'putchar(c), which takes the variable as its argument and sends 
  299. it to the standard output device, ie the screen.
  300.  
  301. Enter the following program to see these working:
  302.  
  303.  
  304.  
  305. # include "stdio.h"
  306.  
  307. main()
  308. {
  309.    char c;          /* the variable for input and output */
  310.  
  311.    printf("Enter characters, 'Q' will finish program\n\n");
  312.  
  313.    do                               /* start of DO...WHILE loop     */
  314.    {
  315.       c=getchar();                  /* get a key press              */
  316.  
  317.       putchar(c);                   /* print it on screen           */
  318.  
  319.     }
  320.     while (c != 'Q');               /* while its not equal to Q    */
  321.  
  322.     printf("\nOk, press a key to go to desktop.");
  323.     c=getchar();
  324.    
  325.  }
  326.  
  327. If you entered this example you should have noticed two things.
  328.  
  329. 1) The getchar() function  echoes the key press to the screen in all cases 
  330. until the DO...WHILE conditions are false, ie 'Q' was pressed.
  331.  
  332. 2) The function acts like the INKEY$ function in BASIC. It  does  not  re-
  333. quire the Enter key to be pressed. Unlike the INKEY$ function it will wait 
  334. until a key is pressed.
  335.  
  336.  
  337.  
  338. I'll finish this tutorial with a short program to print out a  multiplica-
  339. tion table between 2 and 9. It will use the arithmetic and  logic  expres-
  340. sions given in this article as well as a FOR loop. 
  341.  
  342. The only point to be aware of is that there is absolutely no error  check-
  343. ing and that pressing keys other than the numbers 2 - 9  will give  create
  344. funny tables. A copy of my C work disc to the first person who can tell me 
  345. why (I do know - really).
  346.  
  347.  
  348.  
  349. # include "stdio.h"
  350.  
  351. main()
  352. {
  353.    int i,j,c;                            /* 3 integer variables   */
  354.  
  355.    do
  356.    {
  357.       printf("\nEnter a number between 1 and 10\n\n");
  358.      
  359.       i=getchar();                       /* get the keypress      */
  360.  
  361.       i=i-48;                            /* subtract 48 from ASCII*/
  362.  
  363.       printf(" times table\n");          /* getchar() echoes to screen */
  364.  
  365.       for (j=1;j<13;j++)                 /* loop between 1 and 12  */
  366.       {
  367.          printf("%d x %d = %d\n",i,j,i*j);
  368.        }
  369.    
  370.       printf("\n\nPress any key to continue, 'Q' to quit");
  371.  
  372.       c=getchar();
  373.     }
  374.    while (c != 'Q');                     /* loop while c <> Q     */
  375.  }   
  376.  
  377.  
  378. Don't be afraid to experiment and try out different ways of doing the same 
  379. thing. Only change one thing at a time so that you don't get confused with 
  380. more that one error. Always look for the obvious  such  as  missing  semi-
  381. colons when your compiler throws a wobbly.
  382.  
  383.                                                                Dave Mooney
  384.  
  385.  
  386.                                 ~~~OOOO~~~
  387.  
  388.  
  389.